Langkah Pertama ke Komputasi Kuantum

Tingkat Kesulitan: Pemula
Penggunaan waktu QPU: 11 detik

Selamat datang, para hacker! Kami sangat senang kamu bisa hadir di workshop ini. Tujuan utama hands-on pengantar ini adalah mempersiapkan kamu untuk memulai perjalanan kuantum dengan cara: 1) membimbing kamu cara menginstal qiskit, 2) cara membuat akun IBM Cloud dan menyiapkan api_key dan crn untuk menggunakan komputer kuantum sungguhan, 3) membuat Circuit kuantum pertama kamu, 4) menyelesaikan kuis state kuantum, dan 5) menjalankan Circuit kamu di komputer kuantum sungguhan dan memplot hasilnya.

1. Hal pertama yang perlu diketahui: Qiskit

Apa itu Qiskit

Qiskit SDK adalah tumpukan perangkat lunak berperforma tinggi yang dibangun untuk membantu pengembang dan peneliti memanfaatkan sepenuhnya kekuatan komputer kuantum pada skala utilitas dan seterusnya. Inti dari ekosistemnya adalah Qiskit SDK, sebuah kit pengembangan perangkat lunak open source untuk bekerja dengan komputer kuantum di tingkat Circuit kuantum yang diperluas. Operator dan primitif. Qiskit SDK memungkinkan siapa pun mendapatkan performa optimal dari komputer kuantum nyata menggunakan lingkungan komputasi yang mereka sukai.

Selain SDK-nya, Qiskit juga mencakup serangkaian alat dan layanan berperforma tinggi seperti Qiskit Runtime Service, yang memungkinkan komputasi teroptimasi di komputer kuantum IBM melalui cloud menggunakan primitif yang mengelola mitigasi error. Qiskit Transpiler service, yang menyediakan metode heuristik dan berbasis AI mutakhir yang meningkatkan performa untuk tugas-tugas optimasi Circuit kuantum yang umum.

Qiskit functions, katalog layanan IBM dan pihak ketiga yang memudahkan optimasi beban kerja dan penggunaan Qiskit untuk kasus penggunaan industri. Baik kamu adalah pengembang perangkat lunak kuantum, eksperimentalis kuantum, ilmuwan komputasi, atau baru memulai — kerangka kerja Qiskit yang modular dan fleksibel memungkinkan kamu bekerja pada tingkat abstraksi yang paling sesuai dengan kebutuhanmu.

Qiskit dirancang untuk skalabilitas dan kustomisasi, sehingga kamu bisa mendapatkan performa terbaik di industri dan menangani jenis masalah baru. Basis kode berperforma tinggi berarti Qiskit SDK bekerja lebih cepat, menggunakan lebih sedikit memori, dan memberikan hasil yang lebih baik dari sebelumnya. Dan Qiskit juga memperkenalkan kamu ke komunitas pengguna dan pengembang yang luas dan bersemangat untuk menyambutmu serta membantu menjawab pertanyaanmu. Diluncurkan pertama kali pada 2019, program Qiskit advocate adalah inisiatif berbasis komunitas global yang merekrut para profesional dan penggemar komputasi kuantum dari seluruh dunia. Selama bertahun-tahun, para advocate telah menjadi pemimpin yang diakui di komunitas kuantum. Mau jadi pemimpin kuantum berikutnya? Jangan ragu untuk mendaftar - di sini

Menginstal Qiskit

Pertama, pastikan versi Python yang kamu gunakan di lingkunganmu adalah python>=3.10, agar kompatibel dengan versi Qiskit terbaru yang akan kita gunakan

from platform import python_version

print(python_version())

Jika bukan itu, kamu bisa mengupgradenya menggunakan alat yang kamu sukai. Jika tidak yakin caranya, beberapa opsi yang disarankan adalah:

MacOS: Homebrew
Linux: sudo apt-get update

Panduan lengkap cara mengupgrade Python tergantung OS kamu ada di sini: Cara update Python

Untuk informasi lebih lanjut, lihat wiki QGSS (Qiskit Global Summer School) 2025: https://github.com/qiskit-community/qgss-2025/wiki/Jupyter-Notebook-Environment-(Local-and-Online)

Kamu bisa memverifikasi instalasimu dengan menjalankan cell di bawah ini. Jika instalasi berhasil, ini akan mengembalikan versi qiskit.

# Added by doQumentation — required packages for this notebook
!pip install -q numpy qiskit

%pip install 'qiskit[visualization]'
%pip install qiskit-ibm-runtime
%pip install qiskit-aer

import qiskit

print(f"Qiskit version: {qiskit.__version__}")

Pemecahan Masalah

Jika cell sebelumnya menampilkan error, kamu bisa memilih untuk menginstal Qiskit di lingkungan virtual (dua metode yang disarankan berikut). Jika tidak ada error, kamu bisa mengabaikan cell ini dan lanjut ke berikutnya.

Di sini kami mengusulkan dua metode berbeda untuk mengatur lingkungan virtual guna menginstal Qiskit.

Menggunakan venv, seperti yang dijelaskan dalam panduan instalasi Qiskit.
Menggunakan conda, seperti yang dijelaskan dalam video Coding with Qiskit.

2. Siapkan akun IBM Cloud kamu

Untuk menggunakan komputer kuantum sungguhan, kamu perlu api key - tiket masuk utama ke cloud dan crn - token yang akan menghubungkan sumber dayamu dengan menyiapkan akunmu.

Siapkan akunmu sebagai berikut:

Buka IBM Quantum® Platform.
Pergi ke sudut kanan atas (seperti yang ditunjukkan pada gambar di atas), buat API token kamu, dan salin ke lokasi yang aman.
Di cell berikutnya, ganti deleteThisAndPasteYourAPIKeyHere dengan API key kamu.
Pergi ke sudut kiri bawah (seperti yang ditunjukkan pada gambar di atas) dan buat instance kamu. Pastikan memilih open plan.
Setelah instance dibuat, salin kode CRN yang terkait. Kamu mungkin perlu me-refresh untuk melihat instance tersebut.
Di cell di bawah, ganti deleteThisAndPasteYourCRNHere dengan kode CRN kamu.

Lihat panduan ini untuk detail lebih lanjut tentang cara menyiapkan akun IBM Cloud® kamu.

⚠️ Catatan: Perlakukan API key kamu seperti password yang aman. Lihat panduan Cloud setup untuk informasi lebih lanjut tentang menggunakan API key kamu di lingkungan yang aman maupun tidak tepercaya.

Selain itu, jika kamu adalah anggota universitas jaringan mitra IBM, gunakan alamat email institusimu untuk IBM ID kamu agar mendapatkan manfaat mitra.

from qiskit_ibm_runtime import QiskitRuntimeService

# Save your API key and crn and have access to the quantum computers
your_api_key = "deleteThisAndPasteYourAPIKeyHere"
your_crn = "deleteThisAndPasteYourCRNHere"

QiskitRuntimeService.save_account(
    channel="ibm_cloud",
    token=your_api_key,
    instance=your_crn,
    overwrite=True
)

# Check that the account has been saved properly
service = QiskitRuntimeService()
service.saved_accounts()

# See backends you can use
service.backends()

3. Circuit Kuantum Pertama Kamu

Circuit kuantum

Unit dasar Qiskit adalah circuit kuantum, yaitu serangkaian instruksi yang dapat digunakan komputer kuantum untuk bekerja dengan bit informasi kuantum, yang juga dikenal sebagai qubit. Qubit-qubit ini memiliki sifat khusus yang memungkinkan komputer kuantum mendekati masalah secara berbeda dari laptop atau iPhone kamu. Qiskit berkembang pesat sebagai teknologi -- meskipun kamu masih bisa merancang circuit kuantum secara manual dan memutuskan bagaimana kamu ingin menjalankannya (dan ada banyak alasan bagus untuk melakukannya), IBM Quantum juga menyediakan alat yang menyederhanakan prosesnya. Untuk keperluan belajar, kita akan merancang circuit yang sangat sederhana dan menjalankannya pada simulator.

Kita akan melewati gambaran umum ini dengan cepat karena, jujur saja, kita bisa menghabiskan berjam-jam hanya untuk menjelaskan dasar-dasar informasi dan komputasi kuantum. Nyatanya, IBM Quantum sudah melakukan ini, menghasilkan kursus tertulis dan serangkaian kuliah video yang didedikasikan untuk topik ini. Jika kamu membutuhkan penyegaran, coba periksa!

from qiskit import QuantumCircuit
from qiskit.quantum_info import Statevector
from qiskit.visualization import plot_state_qsphere
from qiskit_aer import AerSimulator
from qiskit_ibm_runtime import QiskitRuntimeService
from qiskit_ibm_runtime import SamplerV2 as Sampler
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
from qiskit.transpiler import generate_preset_pass_manager
from qiskit.visualization import array_to_latex
from qiskit.visualization import plot_distribution

import numpy as np
from numpy import sqrt

Operasi Dasar pada Qubit dan Pengukuran

Menuliskan state qubit tunggal

Mari kita mulai dengan melihat sebuah Qubit tunggal. Perbedaan utama antara bit klasik, yang hanya bisa bernilai 0 dan 1, adalah bahwa bit kuantum, atau Qubit, bisa berada dalam state $\vert0\rangle$ , $\vert1\rangle$ , maupun kombinasi linear dari kedua state tersebut. Fitur ini dikenal sebagai superposisi, dan memungkinkan kita menuliskan state paling umum dari sebuah Qubit sebagai:

$\vert\psi\rangle = \sqrt{1-p}\vert0\rangle + e^{i \phi} \sqrt{p} \vert1\rangle$

Jika kita mengukur state Qubit ini, kita akan menemukan hasil $1$ dengan probabilitas $p$ , dan hasil $0$ dengan probabilitas $1-p$ . Seperti yang bisa kamu lihat, total probabilitasnya adalah $1$ , artinya kita memang akan mengukur $0$ atau $1$ , dan tidak ada hasil lain yang mungkin.

Selain $p$ , kamu mungkin juga memperhatikan parameter lain di atas. Variabel $\phi$ menunjukkan fase kuantum relatif antara kedua state $\vert0\rangle$ dan $\vert1\rangle$ . Seperti yang akan kita temukan nanti, fase relatif ini cukup penting. Untuk saat ini, cukup diketahui bahwa fase kuantum inilah yang memungkinkan interferensi antar state kuantum, sehingga kita bisa menulis algoritma kuantum untuk menyelesaikan tugas-tugas tertentu.

Memvisualisasikan state kuantum

Kita memvisualisasikan state kuantum sepanjang latihan ini menggunakan apa yang dikenal sebagai qsphere. Berikut tampilan qsphere untuk state $\vert0\rangle$ dan $\vert1\rangle$ , masing-masing. Perhatikan bahwa bagian paling atas bola mewakili state $\vert0\rangle$ , sedangkan bagian bawah mewakili $\vert1\rangle$ .

#visualize |0>
sv=Statevector([1, 0])
plot_state_qsphere(sv)

Kamu bisa membuat QSphere yang persis sama menggunakan sebuah Circuit kuantum. Statevector yang digunakan di sini berasal dari state $|0\rangle$ . Di Qiskit, Qubit diinisialisasi dalam state $|0\rangle$ . Coba jalankan Circuit di bawah ini dan lihat apakah kamu bisa mendapatkan QSphere yang sama.

qc1 = QuantumCircuit(1)
sv=Statevector(qc1)
plot_state_qsphere(sv)

Sekarang mari kita visualisasikan State $|1\rangle$ . Tidak mengejutkan bahwa state superposisi dengan fase kuantum $\phi = 0$ dan probabilitas $p = 1/2$ (artinya kemungkinan mengukur 0 dan 1 sama besar) ditampilkan di qsphere dengan dua titik. Namun, perhatikan juga bahwa ukuran lingkaran di kedua titik lebih kecil dibandingkan saat kita hanya memiliki $\vert0\rangle$ dan $\vert1\rangle$ di atas. Ini karena ukuran lingkaran sebanding dengan probabilitas mengukur masing-masing, yang kini berkurang setengahnya.

#visualize 1/sqrt(2)|0> + 1/sqrt(2)|1>

sv=Statevector([1/sqrt(2), 1/sqrt(2)])
plot_state_qsphere(sv)

Dalam kasus state superposisi, di mana fase kuantum tidak nol, qsphere memungkinkan kita memvisualisasikan fase tersebut dengan mengubah warna blob yang bersangkutan. Sebagai contoh, state dengan $\phi = 90^\circ$ (derajat) dan probabilitas $p = 1/2$ ditampilkan di qsphere di bawah ini.

sv=Statevector([1/sqrt(2), 1/sqrt(2)*1j])
plot_state_qsphere(sv)

Memanipulasi qubit

Qubit dimanipulasi dengan menerapkan gate kuantum. Mari kita lihat gambaran umum berbagai gate yang akan kita gunakan dalam latihan-latihan berikut.

Pertama, mari kita jelaskan cara mengubah nilai $p$ pada keadaan kuantum umum kita. Untuk melakukannya, kita akan menggunakan dua gate:

$X$ -gate: Gate ini membalik antara dua keadaan $\vert0\rangle$ dan $\vert1\rangle$ . Operasi ini sama dengan gate NOT klasik. Oleh karena itu, $X$ -gate kadang disebut sebagai bit flip atau gate NOT. Secara matematis, gate $X$ mengubah $p$ menjadi $1-p$ , khususnya dari 0 ke 1, dan sebaliknya.
$H$ -gate: Gate ini memungkinkan kita berpindah dari keadaan $\vert0\rangle$ ke keadaan $\frac{1}{\sqrt{2}}\left(\vert0\rangle + \vert1\rangle\right)$ . Keadaan ini juga dikenal sebagai $\vert+\rangle$ . Secara matematis, ini berarti berpindah dari $p=0, \phi=0$ ke $p=1/2, \phi=0$ . Karena keadaan akhir qubit adalah superposisi dari $\vert0\rangle$ dan $\vert1\rangle$ , gate Hadamard merepresentasikan operasi kuantum yang sesungguhnya.

Perhatikan bahwa kedua gate mengubah nilai $p$ , tapi tidak $\phi$ . Beruntungnya, cukup mudah untuk memvisualisasikan aksi gate-gate ini dengan melihat gambar di bawah.

Setelah kita memiliki keadaan $\vert+\rangle$ , kita dapat mengubah fase kuantum dengan menerapkan beberapa gate lainnya. Misalnya, gate $S$ menambahkan fase sebesar $90$ derajat ke $\phi$ , sementara gate $Z$ menambahkan fase sebesar $180$ derajat ke $\phi$ . Untuk mengurangi fase sebesar $90$ derajat, kita dapat menerapkan gate $S^\dagger$ , yang dibaca sebagai S-dagger, dan umum ditulis sebagai sdg. Terakhir, ada gate $Y$ yang menerapkan serangkaian gate $Z$ dan $X$ .

Kamu bisa bereksperimen dengan gate $X$ , $Y$ , $Z$ , $H$ , $S$ dan $S^\dagger$ untuk membiasakan diri dengan berbagai operasi dan bagaimana pengaruhnya terhadap keadaan qubit. Untuk melakukannya, kamu bisa mengunjungi Circuit Composer dan memulai widget circuit kita. Setelah mengunjungi circuit composer, pilih gate untuk diterapkan ke qubit, lalu pilih qubit-nya (pada contoh pertama, satu-satunya qubit yang bisa dipilih adalah qubit 0). Perhatikan bagaimana keadaan yang sesuai berubah dengan setiap gate, beserta deskripsinya. Ini juga akan memberikan kode yang membuat circuit kuantum yang sesuai di Qiskit.

Jika kamu ingin mempelajari lebih lanjut tentang mendeskripsikan keadaan kuantum, operator Pauli, dan gate single-qubit lainnya, lihat Quantum Information dari Single System pada Kursus Basics of Quantum Information oleh John Watrous.

Latihan: Circuit Kuantum Menggunakan Gate Single-Qubit

Berikut empat latihan kecil untuk mencapai berbagai keadaan pada qsphere. Kamu bisa menyelesaikannya dengan circuit composer lalu copy-paste kode yang diberikannya ke cell masing-masing untuk membuat circuit kuantum, atau langsung memasukkan kombinasi baris kode berikut ke dalam program untuk menerapkan gate-gate yang berbeda:

qc.x(0) # bit flip qc.y(0) # bit and phase flip qc.z(0) # phase flip qc.h(0) # superpostion qc.s(0) # quantum phase rotation by pi/2 (90 degrees) qc.sdg(0) # quantum phase rotation by -pi/2 (90 degrees)

Angka (0) menunjukkan bahwa kita menerapkan gate ini ke qubit q0, yaitu qubit pertama (dan dalam kasus ini satu-satunya).

Cobalah untuk mencapai keadaan yang diberikan pada qsphere di setiap latihan berikut.

i) Mari mulai dengan melakukan bit flip. Tujuannya adalah mencapai keadaan $\vert1\rangle$ dari keadaan $\vert0\rangle$ .

def create_circuit():
    qc = QuantumCircuit(1)
    #
    #
    # FILL YOUR CODE IN HERE
    #
    #
    return qc

# check solution
qc2 = create_circuit()
state = Statevector(qc2)

plot_state_qsphere(state, show_state_labels=True, show_state_phases = True, use_degrees = True)

ii) Selanjutnya, mari buat superposisi. Tujuannya adalah mencapai keadaan $|+\rangle = \frac{1}{\sqrt{2}}\left(|0\rangle + |1\rangle\right)$ .

def create_circuit2():
    qc = QuantumCircuit(1)
    #
    #
    # FILL YOUR CODE IN HERE
    #
    #
    return qc

qc3 = create_circuit2()
state = Statevector(qc3)
plot_state_qsphere(state, show_state_labels=True, show_state_phases = True, use_degrees = True)

iii) Mari gabungkan keduanya. Tujuannya adalah mencapai keadaan $|-\rangle = \frac{1}{\sqrt{2}}\left(|0\rangle - |1\rangle\right)$ .

Bisakah kamu menggabungkan dua tugas di atas untuk menemukan solusinya?

def create_circuit3():
    qc = QuantumCircuit(1)
    #
    #
    # FILL YOUR CODE IN HERE
    #
    #
    return qc

qc4 = create_circuit3()
state = Statevector(qc4)
plot_state_qsphere(state, show_state_labels=True, show_state_phases = True, use_degrees = True)

iv) Terakhir, kita beralih ke bilangan kompleks. Tujuannya adalah mencapai keadaan $|\circlearrowleft\rangle = \frac{1}{\sqrt{2}}\left(|0\rangle - i|1\rangle\right)$

def create_circuit4():
    qc = QuantumCircuit(1)
    #
    #
    # FILL YOUR CODE IN HERE
    #
    #
    return qc

qc5 = create_circuit4()
state = Statevector(qc5)

plot_state_qsphere(state, show_state_labels=True, show_state_phases = True, use_degrees = True)

4. Kuis Kuantum dengan Gate Multi-Qubit

Kerja bagus! Sekarang kamu sudah memahami gate single-qubit, mari kita lihat gate yang beroperasi pada beberapa qubit. Di sini kamu akan diminta menyelesaikan 4 kuis keadaan kuantum dengan mengombinasikan gate single-qubit dan gate multi-qubit. Gate dasar untuk dua qubit adalah:

qc.cx(c,t) # controlled-X (= CNOT) gate with control qubit c and target qubit t qc.cz(c,t) # controlled-Z gate with control qubit c and target qubit t qc.swap(a,b) # SWAP gate that swaps the states of qubit a and qubit b

Jika kamu ingin membaca lebih lanjut tentang berbagai gate multi-qubit dan hubungannya, kunjungi Quantum Information dari multiple systems, dalam Kursus Basics of Quantum Information milik John.

Perlu diingat bahwa untuk dua qubit, keadaan umum berbentuk $a|00\rangle + b |01\rangle + c |10\rangle + d|11\rangle$ , di mana $a$ , $b$ , $c$ , dan $d$ adalah bilangan kompleks yang nilai absolutnya dikuadratkan memberikan probabilitas untuk mengukur keadaan tersebut; misalnya, $|a|^2$ adalah probabilitas untuk berakhir pada keadaan '0' pada kedua qubit. Ini berarti sekarang kita bisa memiliki hingga empat titik pada qsphere.

Kita mulai dengan gate dua qubit yang paling umum, yaitu gate controlled-NOT (juga disebut CNOT atau CX). Di sini, seperti semua gate dua qubit yang terkontrol, satu qubit dilabeli sebagai "kontrol", sedangkan yang lainnya disebut "target". Jika qubit kontrol berada dalam keadaan $|0\rangle$ , gate identitas $I$ diterapkan ke target, artinya tidak ada operasi yang dilakukan. Sebaliknya, jika qubit kontrol berada dalam keadaan $|1\rangle$ , gate X diterapkan ke qubit target. Oleh karena itu, dengan kedua qubit berada dalam salah satu dari dua keadaan klasik, $|0\rangle$ atau $|1\rangle$ , gate CNOT terbatas pada operasi klasik.

Situasi ini berubah drastis ketika kita pertama kali menerapkan gate Hadamard ke qubit kontrol, membawanya ke keadaan superposisi $|+\rangle$ . Aksi gate CNOT pada input non-klasik ini dapat menghasilkan keadaan yang sangat terbelit antara qubit kontrol dan target. Jika qubit target awalnya berada dalam keadaan $|0\rangle$ , keadaan yang dihasilkan dilambangkan dengan $|\Phi^+\rangle$ , dan merupakan salah satu dari yang disebut Bell states.

i) Buat Bell state $|\Phi^+\rangle = \frac{1}{\sqrt{2}}\left(|00\rangle + |11\rangle\right)$ .

Untuk keadaan ini kita akan memiliki probabilitas $\frac{1}{2}$ untuk mengukur "00" dan probabilitas $\frac{1}{2}$ untuk mengukur "11". Dengan demikian, hasil kedua qubit berkorelasi sempurna.

def create_circuit5():
    qc = QuantumCircuit(2)
    #
    #
    # FILL YOUR CODE IN HERE
    #
    #
    return qc

qc6 = create_circuit5()
state = Statevector(qc6) # determine final state after running the circuit
display(array_to_latex(state))
display(plot_state_qsphere(state, show_state_labels=True, show_state_phases = True, use_degrees = True))
qc6.draw(output='mpl') # we draw the circuit

Selanjutnya, coba buat keadaan qubit yang berkorelasi sempurna secara anti. Perhatikan tanda minus di sini, yang menunjukkan fase relatif antara dua keadaan.

ii) Buat Bell state $\vert\Psi^-\rangle = \frac{1}{\sqrt{2}}\left(\vert01\rangle - \vert10\rangle\right)$ .

def create_circuit6():
    qc = QuantumCircuit(2)
    #
    #
    # FILL YOUR CODE IN HERE
    #
    #
    return qc

qc7 = create_circuit6()
state = Statevector(qc7) # determine final state after running the circuit
display(array_to_latex(state))
display(plot_state_qsphere(state, show_state_labels=True, show_state_phases = True, use_degrees = True))
qc7.draw(output='mpl') # we draw the circuit

iii) Kamu diberikan quantum circuit yang dideskripsikan dalam fungsi di bawah ini. Tukar keadaan qubit pertama dan kedua untuk mendapatkan QSphere ini.

def create_circuit7():
    qc = QuantumCircuit(2)
    qc.rx(np.pi/3,0)
    qc.x(1)
    return qc

qc8 = create_circuit7()

#
#
# FILL YOUR CODE IN HERE
#
#

state = Statevector(qc8) # determine final state after running the circuit
display(array_to_latex(state))
display(plot_state_qsphere(state, show_state_labels=True, show_state_phases = True, use_degrees = True))
qc8.draw(output='mpl') # we draw the circuit

iv) Tulis program dari awal yang membuat keadaan GHZ (pada tiga qubit), $\vert \text{GHZ}\rangle = \frac{1}{\sqrt{2}} \left(|000\rangle + |111 \rangle \right)$

def create_circuit8():
    #
    #
    # FILL YOUR CODE IN HERE
    #
    #
    #
    return qc

qc9 = create_circuit8()

pub4 = (qc9)

state = Statevector(qc9) # determine final state after running the circuit
display(array_to_latex(state))
display(plot_state_qsphere(state, show_state_labels=True, show_state_phases = True, use_degrees = True))
qc9.draw(output='mpl') # we draw the circuit

5. Jalankan Circuit kamu dan lihat hasil pengukurannya dengan komputer kuantum nyata

Sekarang kita sudah tahu cara membangun quantum circuit untuk memanipulasi statevector dari qubit. Dan inilah saatnya bagian yang paling menarik: menjalankannya dan melihat hasilnya! Di sini kita akan belajar cara modern dan efektif untuk mengeksekusi circuit kita menggunakan Qiskit.

Pola Qiskit adalah kerangka kerja umum untuk memecah masalah domain-spesifik dan mengontekstualisasikan kapabilitas yang diperlukan dalam beberapa tahap. Ini memungkinkan komposabilitas yang mulus dari kapabilitas baru yang dikembangkan oleh peneliti IBM Quantum (dan lainnya) serta mengaktifkan masa depan di mana tugas komputasi kuantum dilakukan oleh infrastruktur komputasi heterogen yang kuat (CPU/GPU/QPU).

Empat langkah pola Qiskit adalah sebagai berikut:

Map masalah ke quantum circuit dan operator
Optimize untuk hardware target
Execute pada hardware target
Post-process hasil

Kita baru saja menyelesaikan Step 1: Mapping, dengan membangun quantum circuit untuk menghasilkan keadaan kuantum yang diinginkan. Sekarang, mari kita telusuri langkah-langkah berikutnya untuk melihat hasilnya.

Optimize

Di sini kita akan mengatur backend untuk menjalankan circuit - kamu dapat memilih QPU least busy di antara grup QPU yang dapat diakses, atau cukup pilih simulator jika kamu tidak memiliki cukup sisa waktu QPU. Setelah memilih backend, pass_manager akan men-transpile circuit-mu ke set gate native dari backend yang kamu pilih dan mengoptimalkannya agar mendapatkan hasil yang lebih baik. Kamu dapat dengan mudah mendeklarasikan pass_manager menggunakan generate_preset_pass_manager dan mengatur optimization_level, di mana angka yang lebih tinggi menunjukkan lebih banyak langkah optimasi.

Langkah berikutnya sangat menarik - kita akan menjalankan quantum circuit menggunakan Qiskit Runtime!

Kita akan melakukannya menggunakan dua primitif Qiskit:

Sampler mengambil sampel dari register output dari eksekusi satu atau lebih quantum circuit. Outputnya adalah hitungan per pengukuran per-shot.
Estimator menghitung nilai ekspektasi dari satu atau lebih observable terhadap keadaan yang dihasilkan oleh quantum circuit. Outputnya terdiri dari nilai ekspektasi beserta standar errornya.

Di sini, kita akan menggunakan Sampler untuk mengeksekusi circuit kita. Cell kode di bawah menunjukkan cara mendefinisikan backend dan pass manager untuk itu. Kemudian, ini akan menambahkan measurement ke semua circuit dan membuat array quantum circuit (pub) untuk diteruskan ke Sampler.

backend=service.least_busy()
#backend=AerSimulator()

pm = generate_preset_pass_manager(optimization_level=3, backend=backend)
sampler = Sampler(mode=backend)

pub = []
for qc in circ:
    qc.measure_all()
    pub.append(pm.run(qc))

Execute

Mari kita eksekusi circuit kita. Jika ada banyak antrean di cloud, cetak dan simpan job_id untuk digunakan nanti dan periksa job_status. Setelah kamu melihat status job berubah menjadi Done, ambil hasil job tersebut.

job = sampler.run(pub)
job_id = job.job_id()
print(job_id)
job.status()

job_retrived = service.job(job_id)
result = job.result()

Post-process

Langkah terakhir adalah menginterpretasikan visualisasi untuk memahami keadaan kuantum yang telah kita buat. Sebelum memplot beberapa grafik, mari kita kumpulkan semua hitungan dari semua circuit. Kemudian kita akan membuat 4 plot dengan mengategorikan circuit.

result = job.result()
counts_all = [result[k].data.meas.get_counts() for k in range(9)]

Keadaan Qubit Tunggal

plot_distribution([counts_all[0], counts_all[1]], legend =['qc1', 'qc2'])

Keadaan Satu Qubit yang Tersuperposisi

plot_distribution([counts_all[2], counts_all[3], counts_all[4]], legend =['qc3', 'qc4', 'qc5'])

Keadaan Dua Qubit

plot_distribution([counts_all[5], counts_all[6], counts_all[7]],legend =['qc6', 'qc7', 'qc8'] )

Keadaan Tiga Qubit

plot_distribution(counts_all[8], legend=['qc9'])

Further challenge

Apakah kamu menemukan noise dalam hasil eksperimen backend aktual? Menghilangkan noise qubit adalah salah satu area penelitian aktif. Coba berbagai opsi mitigasi dan supresi error Qiskit Runtime untuk melihat bagaimana noise dalam hasil eksekusi berubah! (Catatan) Opsi-opsi ini memungkinkan lebih banyak waktu QPU.

Additional Info

import qiskit, qiskit_ibm_runtime

print("Qiskit version:", qiskit.version.get_version_info())
print("Qiskit Runtime version:", qiskit_ibm_runtime.__version__)

Qiskit version: 2.1.1
Qiskit Runtime version: 0.40.1

Created by: Sophy Shin

Reviewed by: Nate Earnest-Noble

This is licensed under the Apache License, Version 2.0. You may obtain a copy of this license in the LICENSE file in the root directory of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.

Any modifications or derivative works of this must retain this copyright notice, and modified files need to carry a notice indicating that they have been altered from the originals.

1. Hal pertama yang perlu diketahui: Qiskit​

Apa itu Qiskit​

Menginstal Qiskit​

Pemecahan Masalah​

2. Siapkan akun IBM Cloud kamu ​

3. Circuit Kuantum Pertama Kamu​

Circuit kuantum​

Operasi Dasar pada Qubit dan Pengukuran​

Menuliskan state qubit tunggal​

Memvisualisasikan state kuantum​

Memanipulasi qubit​

Latihan: Circuit Kuantum Menggunakan Gate Single-Qubit​

i) Mari mulai dengan melakukan bit flip. Tujuannya adalah mencapai keadaan ∣1⟩\vert1\rangle∣1⟩ dari keadaan ∣0⟩\vert0\rangle∣0⟩.​

ii) Selanjutnya, mari buat superposisi. Tujuannya adalah mencapai keadaan ∣+⟩=12(∣0⟩+∣1⟩)|+\rangle = \frac{1}{\sqrt{2}}\left(|0\rangle + |1\rangle\right)∣+⟩=2​1​(∣0⟩+∣1⟩).​

iii) Mari gabungkan keduanya. Tujuannya adalah mencapai keadaan ∣−⟩=12(∣0⟩−∣1⟩)|-\rangle = \frac{1}{\sqrt{2}}\left(|0\rangle - |1\rangle\right)∣−⟩=2​1​(∣0⟩−∣1⟩).​

iv) Terakhir, kita beralih ke bilangan kompleks. Tujuannya adalah mencapai keadaan ∣↺⟩=12(∣0⟩−i∣1⟩)|\circlearrowleft\rangle = \frac{1}{\sqrt{2}}\left(|0\rangle - i|1\rangle\right)∣↺⟩=2​1​(∣0⟩−i∣1⟩)​

4. Kuis Kuantum dengan Gate Multi-Qubit​

i) Buat Bell state ∣Φ+⟩=12(∣00⟩+∣11⟩)|\Phi^+\rangle = \frac{1}{\sqrt{2}}\left(|00\rangle + |11\rangle\right)∣Φ+⟩=2​1​(∣00⟩+∣11⟩).​

ii) Buat Bell state ∣Ψ−⟩=12(∣01⟩−∣10⟩)\vert\Psi^-\rangle = \frac{1}{\sqrt{2}}\left(\vert01\rangle - \vert10\rangle\right)∣Ψ−⟩=2​1​(∣01⟩−∣10⟩).​

iii) Kamu diberikan quantum circuit yang dideskripsikan dalam fungsi di bawah ini. Tukar keadaan qubit pertama dan kedua untuk mendapatkan QSphere ini.​

iv) Tulis program dari awal yang membuat keadaan GHZ (pada tiga qubit), ∣GHZ⟩=12(∣000⟩+∣111⟩)\vert \text{GHZ}\rangle = \frac{1}{\sqrt{2}} \left(|000\rangle + |111 \rangle \right)∣GHZ⟩=2​1​(∣000⟩+∣111⟩)​

5. Jalankan Circuit kamu dan lihat hasil pengukurannya dengan komputer kuantum nyata​

Optimize​

Execute​

Post-process​

Further challenge​

Additional Info​